﻿using System;
using Bastanteo.Dominio;
using Bastanteo.Negocio;
using Bastanteo.Persistencia;
using NUnit.Framework;
using Spring.Context;
using Spring.Context.Support;

namespace Bastanteo.Pruebas
{
    [TestFixture]
    public class Test7_AdministracionService
    {
        IApplicationContext Spring = null;
        IAdministracionService Service = null;
        Cliente clienteRegistrado = null;
        //Cliente clienteCreado = null;
        BastanteoCombinacion combinacionRegistrado = null;
        Grupo grupoRegistrado = null;
        //Grupo grupoCreado = null;
        Poder poderRegistrado = null;
        Representante representanteRegistrado = null;
        CBastanteo bastanteoRegistrado = null;

        [TestFixtureSetUp]
        public void IniciarPruebas()
        {
            Spring = new XmlApplicationContext(
                "assembly://Bastanteo/Bastanteo/capaPersistencia.xml",
                "assembly://Bastanteo/Bastanteo/capaNegocio.xml"
                );
            Service = (IAdministracionService)Spring.GetObject("administracionService");

        }

        //___________________PODER___________________________________
        [Test]  //Test Registrar Poder Datos Insuficientes
        public void Test1_1_RegistrarPoder_DatosInsuficientes()
        {
            Assert.Catch<DatosInsuficientesException>(delegate
            {
                Service.RegistrarPoder("Cobrar cheques", null);
            });
        }

        [Test]  //Test Registrar Poder OK
        public void Test1_2_RegistrarPoder_Ok()
        {
            Assert.DoesNotThrow(delegate
            {
                poderRegistrado = Service.RegistrarPoder("Cobrar cheques", "A");
            });
            Assert.IsNotNull(poderRegistrado);
            Assert.Greater(poderRegistrado.CodigoPoder, 0);
            Assert.AreEqual(poderRegistrado.Descripcion, "Cobrar cheques");
            Assert.AreEqual(poderRegistrado.TipoProducto, "A");
        }

        [Test]  //Test Registrar Poder Repetido
        public void Test1_3_RegistrarPoder_Repetido()
        {
            Assert.Catch<EntidadRepetidaException>(delegate
            {
                Service.RegistrarPoder("Cobrar cheques", "A");

            });
        }


        //___________________GRUPO___________________________________
        [Test]  //Test Registrar Grupo Datos Insuficientes
        public void Test2_1_RegistrarGrupo_DatosInsuficientes()
        {
            Assert.Catch<DatosInsuficientesException>(delegate
            {
                Service.RegistrarGrupo(null);
            });
        }

        [Test]  //Test Registrar Grupo OK
        public void Test2_2_RegistrarGrupo_Ok()
        {
            Assert.DoesNotThrow(delegate
            {
                grupoRegistrado = Service.RegistrarGrupo("Gerencia General");
            });
            Assert.IsNotNull(grupoRegistrado);
            Assert.Greater(grupoRegistrado.CodigoGrupo, 0);
            Assert.AreEqual(grupoRegistrado.Descripcion, "Gerencia General");
        }

        [Test]  //Test Registrar Grupo Repetido
        public void Test2_3_RegistrarGrupo_Repetido()
        {
            Assert.Catch<EntidadRepetidaException>(delegate
            {
                Service.RegistrarGrupo("Gerencia General");
            });
        }


        //___________________CLIENTE___________________________________
        [Test]  //Test Registrar Clientes Datos Insuficientes valida que los datos ingresados no sean nulos
        public void Test3_1_RegistrarCliente_DatosInsuficientes()
        {
            Assert.Catch<DatosInsuficientesException>(delegate
            {
                Service.RegistrarCliente("12345678901", "UPC", DateTime.Now, null, 0);
            });
        }

        [Test]  //Test Registrar Cliente OK 
        public void Test3_2_RegistrarCliente_Ok()
        {
            Assert.DoesNotThrow(delegate
            {
                clienteRegistrado = Service.RegistrarCliente("12345678901", "UPC", DateTime.Now, "SAC", 10);
            });


            Assert.IsNotNull(clienteRegistrado);
            Assert.Greater(clienteRegistrado.CodigoCliente, 0);
            Assert.AreEqual(clienteRegistrado.Ruc, "12345678901");
            Assert.AreEqual(clienteRegistrado.RazonSocial, "UPC");
            Assert.AreEqual(clienteRegistrado.TipoEmpresa, "SAC");
            Assert.AreEqual(clienteRegistrado.CantidadEmpleados, 10);
        }

        [Test]  //Test Registrar Cliente Repetido
        public void Test3_3_RegistrarCliente_Repetido()
        {
            Assert.Catch<EntidadRepetidaException>(delegate
            {
                Service.RegistrarCliente("12345678901", "UPC", DateTime.Now, "SAC", 10);
            });
        }


        //___________________REPRESENTANTE___________________________________
        [Test]  //Test Registrar Representantes Datos Insuficientes
        public void Test4_1_RegistrarRepresentante_DatosInsuficientes()
        {


            Assert.Catch<DatosInsuficientesException>(delegate
            {
                Service.RegistrarRepresentante(clienteRegistrado, "DNI", "32344326", "Lucia", null, grupoRegistrado, "Analista");
            });
        }

        [Test]  //Test Registrar Representante OK
        public void Test4_2_RegistrarRepresentante_Ok()
        {



            Assert.DoesNotThrow(delegate
            {
                representanteRegistrado = Service.RegistrarRepresentante(clienteRegistrado, "DNI", "43456789", "Maria", "Gonzales", grupoRegistrado, "Jefa");
            });
            Assert.IsNotNull(representanteRegistrado);
            Assert.Greater(representanteRegistrado.CodigoRepresentante, 0);
            Assert.AreEqual(representanteRegistrado.Cliente, clienteRegistrado);
            Assert.AreEqual(representanteRegistrado.NumeroDocumento, "43456789");
            Assert.AreEqual(representanteRegistrado.Nombres, "Maria");
            Assert.AreEqual(representanteRegistrado.Apellidos, "Gonzales");
            Assert.AreEqual(representanteRegistrado.Grupo, grupoRegistrado);
            Assert.AreEqual(representanteRegistrado.Cargo, "Jefa");
        }

        [Test]  //Test Registrar Representante Repetido
        public void Test4_3_RegistrarRepresentante_Repetido()
        {



            Assert.Catch<EntidadRepetidaException>(delegate
            {
                Service.RegistrarRepresentante(clienteRegistrado, "DNI", "43456789", "Maria", "Gonzales", grupoRegistrado, "Jefa");


            });
        }


        //___________________BASTANTEO___________________________________
        [Test]  //Test Registrar Clientes Datos Insuficientes
        public void Test5_1_RegistrarBastanteo_DatosInsuficientes()
        {
            Assert.Catch<DatosInsuficientesException>(delegate
            {
                Service.RegistrarBastanteo(grupoRegistrado.CodigoGrupo, poderRegistrado.CodigoPoder, 100, DateTime.Now, null);
            });
        }

        [Test]  //Test Registrar Bastanteo OK
        public void Test5_2_RegistrarBastanteo_Ok()
        {
            Assert.DoesNotThrow(delegate
            {
                bastanteoRegistrado = Service.RegistrarBastanteo(grupoRegistrado.CodigoGrupo, poderRegistrado.CodigoPoder, 100, DateTime.Now, "A");
            });
            Assert.IsNotNull(bastanteoRegistrado);
            Assert.Greater(bastanteoRegistrado.CodigoBastanteo, 0);
            Assert.AreEqual(bastanteoRegistrado.CodigoGrupo.CodigoGrupo, grupoRegistrado.CodigoGrupo);
            Assert.AreEqual(bastanteoRegistrado.CodigoPoder.CodigoPoder, poderRegistrado.CodigoPoder);
            Assert.AreEqual(bastanteoRegistrado.ImporteLimite, 100);
            Assert.AreEqual(bastanteoRegistrado.TipoIntervencion, "A");
        }

        [Test]  //Test Registrar Bastanteo Repetido
        public void Test5_3_RegistrarBastanteo_Repetido()
        {
            Assert.Catch<EntidadRepetidaException>(delegate
            {
                Service.RegistrarBastanteo(grupoRegistrado.CodigoGrupo, poderRegistrado.CodigoPoder, 100, DateTime.Now, "A");

            });
        }


        //___________________COMBINACION___________________________________
        [Test]  //Test agregar Combinación Datos Insuficientes
        public void Test6_1_AgregarCombinacion_DatosInsuficientes()
        {
            Assert.Catch<DatosInsuficientesException>(delegate
            {
                Service.AgregarCombinacion(bastanteoRegistrado.CodigoBastanteo, 0);
            });
        }

        [Test]  //Test agregar Combinación OK
        public void Test6_2_AgregarCombinacion_Ok()
        {
            Assert.DoesNotThrow(delegate
            {
                combinacionRegistrado = Service.AgregarCombinacion(bastanteoRegistrado.CodigoBastanteo, grupoRegistrado.CodigoGrupo);
            });
            Assert.IsNotNull(combinacionRegistrado);
            Assert.Greater(combinacionRegistrado.CodigoBastanteoCombinacion, 0);
            Assert.AreEqual(combinacionRegistrado.CodigoBastanteo.CodigoBastanteo, bastanteoRegistrado.CodigoBastanteo);
            Assert.AreEqual(combinacionRegistrado.Grupo.CodigoGrupo, grupoRegistrado.CodigoGrupo);
        }


        [Test]  //Test agregar Combinación datos duplicados
        public void Test6_3_AgregarCombinacion_Repetido()
        {
            Assert.Catch<EntidadRepetidaException>(delegate
            {
                Service.AgregarCombinacion(bastanteoRegistrado.CodigoBastanteo, grupoRegistrado.CodigoGrupo);
            });
        }


        [Test]  //Test Eliminar Poder Relacionado
        public void Test7_1_EliminarPoder_Relacionado()
        {
            Assert.Catch<EntidadRelacionadaException>(delegate
            {
                Service.EliminarPoder(poderRegistrado.CodigoPoder);
            });
        }



        [Test]  //Test Eliminar Poder OK
        public void Test7_2_EliminarPoder_OK()
        {
            Service.EliminarCombinacion(combinacionRegistrado);
            Service.EliminarBastanteo(bastanteoRegistrado);
            Assert.DoesNotThrow(delegate
            {
                Service.EliminarPoder(poderRegistrado.CodigoPoder);
            });
        }



        [TestFixtureTearDown]
        public void FinalizarPruebas()
        {
            /*if (combinacionRegistrado != null)
            {
                ((IBastanteoCombinacionDAO)Spring.GetObject("combinacionDAO_NH")).Eliminar(combinacionRegistrado);
                
            }

            if (bastanteoRegistrado != null)
            {
                ((IBastanteoDAO)Spring.GetObject("bastanteoDAO_NH")).Eliminar(bastanteoRegistrado);
                
            }
            */
            if (representanteRegistrado != null)
            {
                ((IRepresentanteDAO)Spring.GetObject("representanteDAO_NH")).Eliminar(representanteRegistrado);

            }
            /*if (poderRegistrado != null)
            {
                ((IPoderDAO)Spring.GetObject("poderDAO_NH")).Eliminar(poderRegistrado);
                
            }*/
            if (clienteRegistrado != null)
            {
                ((IClienteDAO)Spring.GetObject("clienteDAO_NH")).Eliminar(clienteRegistrado);

            }
            if (grupoRegistrado != null)
            {
                ((IGrupoDAO)Spring.GetObject("grupoDAO_NH")).Eliminar(grupoRegistrado);

            }

            Spring.Dispose();
            Spring = null;
        }
    }
}